package com.library.controller;

import com.library.dto.*;
import com.library.exception.ForbiddenException;
import com.library.service.UserService;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.Map;

/**
 * 用户控制器
 * 处理用户相关的HTTP请求，包括个人信息管理、用户列表管理等
 */
@Slf4j
@RestController
@RequestMapping("/api/users")
@RequiredArgsConstructor
public class UserController {
    private final UserService userService;
    private final HttpServletRequest httpServletRequest;

    /**
     * 获取用户个人信息接口
     * GET /api/users/profile
     * 
     * @param userId 用户ID（从JWT中获取）
     * @return 用户个人信息
     */
    @GetMapping("/profile")
    public ResponseEntity<Map<String, UserDTO>> getUserProfile(@RequestAttribute Long userId) {
        UserDTO user = userService.getUserProfile(userId);
        Map<String, UserDTO> response = new HashMap<>();
        response.put("user", user);
        return ResponseEntity.ok(response);
    }

    /**
     * 更新用户个人信息接口
     * PUT /api/users/profile
     * 
     * @param dto 更新的用户信息
     * @param userId 用户ID（从JWT中获取）
     * @return 更新后的用户信息
     */
    @PutMapping("/profile")
    public ResponseEntity<Map<String, UserDTO>> updateUserProfile(
            @Valid @RequestBody UserProfileDTO dto,
            @RequestAttribute Long userId) {
        UserDTO user = userService.updateUserProfile(userId, dto);
        Map<String, UserDTO> response = new HashMap<>();
        response.put("user", user);
        return ResponseEntity.ok(response);
    }

    /**
     * 修改密码接口
     * PUT /api/users/password
     * 
     * @param dto 密码修改请求
     * @param userId 用户ID（从JWT中获取）
     * @return 修改结果
     */
    @PutMapping("/password")
    public ResponseEntity<Map<String, String>> changePassword(
            @Valid @RequestBody PasswordChangeDTO dto,
            @RequestAttribute Long userId) {
        userService.changePassword(userId, dto);
        Map<String, String> response = new HashMap<>();
        response.put("message", "密码修改成功");
        return ResponseEntity.ok(response);
    }

    /**
     * 用户注销账号接口
     * DELETE /api/users/profile
     *
     * @param userId 用户ID（从JWT中获取）
     * @return 注销结果
     */
    @DeleteMapping("/profile")
    public ResponseEntity<Map<String, String>> deleteAccount(@RequestAttribute Long userId) {
        userService.deleteUserAccount(userId);
        Map<String, String> response = new HashMap<>();
        response.put("message", "账户已注销");
        return ResponseEntity.ok(response);
    }

    /**
     * 获取用户列表接口（管理员）
     * GET /api/users?keyword=xxx&role=xxx&status=xxx&page=1&size=20&sort=createdAt&order=desc
     * 
     * @param keyword 搜索关键词（可选）
     * @param role 用户角色（可选）
     * @param status 用户状态（可选）
     * @param page 页码（可选，默认1）
     * @param size 每页大小（可选，默认20）
     * @param sort 排序字段（可选，默认createdAt）
     * @param order 排序方向（可选，默认desc）
     * currentRole 当前用户角色（从JWT中获取）
     * @return 用户列表（分页）
     */
    @GetMapping
    public ResponseEntity<PageResponse<UserDTO>> getUserList(
            @RequestParam(required = false) String keyword,
            @RequestParam(required = false) String role,
            @RequestParam(required = false) String status,
            @RequestParam(defaultValue = "1") Integer page,
            @RequestParam(defaultValue = "20") Integer size,
            @RequestParam(defaultValue = "createdAt") String sort,
            @RequestParam(defaultValue = "desc") String order,
            HttpServletRequest request
            //@RequestAttribute String currentRole
            ) {
        //从token中解析当前用户角色
        // 直接从请求属性中获取角色
        String currentRole = (String) request.getAttribute("role");

        // 检查管理员权限
        if (!"admin".equals(currentRole)) {
            throw new ForbiddenException("需要管理员权限");
        }

        PageResponse<UserDTO> response = userService.getUserList(keyword, role, status, page, size, sort, order);
        return ResponseEntity.ok(response);
    }

    /**
     * 获取用户详情接口（管理员）
     * GET /api/users/{id}
     * 
     * @param id 用户ID
     *  currentRole 当前用户角色（从JWT中获取）
     * @return 用户详情
     */
    @GetMapping("/{id}")
    public ResponseEntity<Map<String, UserDTO>> getUserById(
            @PathVariable Long id,
            HttpServletRequest request) {
        //从token中解析当前用户角色
        // 直接从请求属性中获取角色
        String currentRole = (String) request.getAttribute("role");
        // 检查管理员权限
        if (!"admin".equals(currentRole)) {
            throw new ForbiddenException("需要管理员权限");
        }

        UserDTO user = userService.getUserById(id);
        Map<String, UserDTO> response = new HashMap<>();
        response.put("user", user);
        return ResponseEntity.ok(response);
    }

    /**
     * 修改用户角色接口（管理员）
     * PUT /api/users/{id}/role
     * 
     * @param id 用户ID
     * @param dto 角色更新请求
     *  currentUserId 当前用户ID（从JWT中获取）
     *  currentRole 当前用户角色（从JWT中获取）
     * @return 更新结果
     */
    @PutMapping("/{id}/role")
    public ResponseEntity<Map<String, String>> updateUserRole(
            @PathVariable Long id,
            @Valid @RequestBody UserRoleUpdateDTO dto,
            HttpServletRequest request) {
        //从token中解析当前用户角色
        // 直接从请求属性中获取角色
        Long currentUserId = (Long) request.getAttribute("id");
        String currentRole = (String) request.getAttribute("role");
        // 检查管理员权限
        if (!"admin".equals(currentRole)) {
            throw new ForbiddenException("需要管理员权限");
        }

        userService.updateUserRole(id, dto.getRole(), currentUserId);
        Map<String, String> response = new HashMap<>();
        response.put("message", "角色更新成功");
        return ResponseEntity.ok(response);
    }

    /**
     * 修改用户状态接口（管理员）
     * PUT /api/users/{id}/status
     * 
     * @param id 用户ID
     * @param dto 状态更新请求
     * @param currentUserId 当前用户ID（从JWT中获取）
     * @param currentRole 当前用户角色（从JWT中获取）
     * @return 更新结果
     */
    @PutMapping("/{id}/status")
    public ResponseEntity<Map<String, String>> updateUserStatus(
            @PathVariable Long id,
            @Valid @RequestBody UserStatusUpdateDTO dto,
            @RequestAttribute Long currentUserId,
            @RequestAttribute String currentRole) {
        
        // 检查管理员权限
        if (!"admin".equals(currentRole)) {
            throw new ForbiddenException("需要管理员权限");
        }

        userService.updateUserStatus(id, dto.getStatus(), currentUserId);
        Map<String, String> response = new HashMap<>();
        response.put("message", "状态更新成功");
        return ResponseEntity.ok(response);
    }
}

